package DateStructure.Class2.ListTest;

import java.util.Arrays;

public class MyArrayList {
    public int[] array;
    public int usedSize;
    public static final int CAPACITY = 10;

    public MyArrayList(){
        array = new int[CAPACITY];
    }

    //初始化
    public void arrayList(int index){
        if(index>0){
            array = Arrays.copyOf(array,array.length+index);
        } else if (index==0) {
            isNull();
        }else{
            IndexIllgal(index);
        }
    }

    //查找该下标的元素
    public int get(int index){
        try{
            isNull();
            IndexIllgal(index);
            return array[index];
        }catch(PosIndexIllgal e){
            e.printStackTrace();
            return -1;
        }catch(NullEmpty e){
            e.printStackTrace();
            return -1;
        }
    }

    //判断顺序表是否为空
    public void isNull(){
        if(Size() == 0){
            throw new NullEmpty("顺序表为空");
        }
    }

    //设置下标元素值
    public void set(int index, int value){
        try{
            isNull();
            IndexIllgal(index);
            array[index] = value;
        }catch(PosIndexIllgal e){
            e.printStackTrace();
        }
    }

    //删除值
    public void delete(int x){
        try{
            isNull();
            int index = indexOf(x);
            if(index == -1){
                return;
            }
            for(int i = index; i < usedSize-1; i++){
                array[i] = array[i+1];
                usedSize--;
            }
        }catch(PosIndexIllgal e){
            e.printStackTrace();
        }catch(NullEmpty e){
            e.printStackTrace();
        }
    }

    //清除顺序表
    public void clear(){
        for(int i = usedSize-1; i >= 0; i--){
            array[i] = 0;
        }
        usedSize = 0;
    }

    //判断该元素是否在顺序表中
    public boolean contains(int x){
        for(int i=0; i<usedSize; i++){
            if(array[i] == x){
                return true;
            }
        }
        return false;
    }

    //获取该元素的下标（最近的）
    public int indexOf(int x){
        for(int i=0; i<usedSize; i++){
            if(array[i] == x){
                return i;
            }
        }
        return -1;
    }

    //打印顺序表
    public void display(){
        try{
            isNull();
            for(int i=0; i<usedSize; i++){
                System.out.print(array[i]+" ");
            }
            System.out.println();
        }catch (NullEmpty e){
            e.printStackTrace();
        }
    }

    //获取顺序表的元素个数
    public int Size(){
        return usedSize;
    }

    //添加元素
    public void add(int x){
        grow();
        array[usedSize] = x;
        usedSize++;
    }

    //在某个下标设置值
    public void add(int index, int x) throws PosIndexIllgal{
        try{
            IndexIllgal(index);
            grow();
            for(int i=usedSize-1; i>=index; i--){
                array[i+1]=array[i];
            }
            array[index]=x;
            usedSize++;
        }
        catch(PosIndexIllgal e){
            System.out.println("下标输入不合法");
            e.printStackTrace();
        }

    }

    //判断下标输入是否合法
    private void IndexIllgal(int index){
        if(index > usedSize||index < 0){
            throw new PosIndexIllgal("下标输入不合法");
        }
    }

    //为顺序表开辟空间
    private void grow(){
        array = Arrays.copyOf(array,array.length+1);
    }

    //判断顺序表是否满了
    public boolean isFull(){
        return usedSize == CAPACITY;
    }

}
